// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
//
// The Google C++ Testing Framework (Google Test)
//
// This header file declares functions and macros used internally by
// Google Test.  They are subject to change without notice.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_

#include "gtest/internal/gtest-port.h"

#if GTEST_OS_LINUX
# include <stdlib.h>
# include <sys/types.h>
# include <sys/wait.h>
# include <unistd.h>
#endif  // GTEST_OS_LINUX

#include <ctype.h>
#include <string.h>
#include <iomanip>
#include <limits>
#include <set>

#include "gtest/internal/gtest-string.h"
#include "gtest/internal/gtest-filepath.h"
#include "gtest/internal/gtest-type-util.h"

// Due to C++ preprocessor weirdness, we need double indirection to
// concatenate two tokens when one of them is __LINE__.  Writing
//
//   foo ## __LINE__
//
// will result in the token foo__LINE__, instead of foo followed by
// the current line number.  For more details, see
// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar

// Google Test defines the testing::Message class to allow construction of
// test messages via the << operator.  The idea is that anything
// streamable to std::ostream can be streamed to a testing::Message.
// This allows a user to use his own types in Google Test assertions by
// overloading the << operator.
//
// util/gtl/stl_logging-inl.h overloads << for STL containers.  These
// overloads cannot be defined in the std namespace, as that will be
// undefined behavior.  Therefore, they are defined in the global
// namespace instead.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test assertions,
// testing::Message must access the custom << operator from the global
// namespace.  Hence this helper function.
//
// Note: Jeffrey Yasskin suggested an alternative fix by "using
// ::operator<<;" in the definition of Message's operator<<.  That fix
// doesn't require a helper function, but unfortunately doesn't
// compile with MSVC.
template <typename T>
inline void GTestStreamToHelper(std::ostream *os, const T &val)
{
    *os << val;
}

class ProtocolMessage;
namespace proto2
{
    class Message;
}

namespace testing
{

    // Forward declarations.

    class AssertionResult;                 // Result of an assertion.
    class Message;                         // Represents a failure message.
    class Test;                            // Represents a test.
    class TestInfo;                        // Information about a test.
    class TestPartResult;                  // Result of a test part.
    class UnitTest;                        // A collection of test cases.

    template <typename T>
    ::std::string PrintToString(const T &value);

    namespace internal
    {

        struct TraceInfo;                      // Information about a trace point.
        class ScopedTrace;                     // Implements scoped trace.
        class TestInfoImpl;                    // Opaque implementation of TestInfo
        class UnitTestImpl;                    // Opaque implementation of UnitTest

        // How many times InitGoogleTest() has been called.
        extern int g_init_gtest_count;

        // The text used in failure messages to indicate the start of the
        // stack trace.
        GTEST_API_ extern const char kStackTraceMarker[];

        // A secret type that Google Test users don't know about.  It has no
        // definition on purpose.  Therefore it's impossible to create a
        // Secret object, which is what we want.
        class Secret;

        // Two overloaded helpers for checking at compile time whether an
        // expression is a null pointer literal (i.e. NULL or any 0-valued
        // compile-time integral constant).  Their return values have
        // different sizes, so we can use sizeof() to test which version is
        // picked by the compiler.  These helpers have no implementations, as
        // we only need their signatures.
        //
        // Given IsNullLiteralHelper(x), the compiler will pick the first
        // version if x can be implicitly converted to Secret*, and pick the
        // second version otherwise.  Since Secret is a secret and incomplete
        // type, the only expression a user can write that has type Secret* is
        // a null pointer literal.  Therefore, we know that x is a null
        // pointer literal if and only if the first version is picked by the
        // compiler.
        char IsNullLiteralHelper(Secret *p);
        char(&IsNullLiteralHelper(...))[2];   // NOLINT

        // A compile-time bool constant that is true if and only if x is a
        // null pointer literal (i.e. NULL or any 0-valued compile-time
        // integral constant).
#ifdef GTEST_ELLIPSIS_NEEDS_POD_
        // We lose support for NULL detection where the compiler doesn't like
        // passing non-POD classes through ellipsis (...).
# define GTEST_IS_NULL_LITERAL_(x) false
#else
# define GTEST_IS_NULL_LITERAL_(x) \
    (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
#endif  // GTEST_ELLIPSIS_NEEDS_POD_

        // Appends the user-supplied message to the Google-Test-generated message.
        GTEST_API_ String AppendUserMessage(const String &gtest_msg,
                                            const Message &user_msg);

        // A helper class for creating scoped traces in user programs.
        class GTEST_API_ ScopedTrace
        {
        public:
            // The c'tor pushes the given source file location and message onto
            // a trace stack maintained by Google Test.
            ScopedTrace(const char *file, int line, const Message &message);

            // The d'tor pops the info pushed by the c'tor.
            //
            // Note that the d'tor is not virtual in order to be efficient.
            // Don't inherit from ScopedTrace!
            ~ScopedTrace();

        private:
            GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
        } GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
        // c'tor and d'tor.  Therefore it doesn't
        // need to be used otherwise.

        // Converts a streamable value to a String.  A NULL pointer is
        // converted to "(null)".  When the input value is a ::string,
        // ::std::string, ::wstring, or ::std::wstring object, each NUL
        // character in it is replaced with "\\0".
        // Declared here but defined in gtest.h, so that it has access
        // to the definition of the Message class, required by the ARM
        // compiler.
        template <typename T>
        String StreamableToString(const T &streamable);

        // The Symbian compiler has a bug that prevents it from selecting the
        // correct overload of FormatForComparisonFailureMessage (see below)
        // unless we pass the first argument by reference.  If we do that,
        // however, Visual Age C++ 10.1 generates a compiler error.  Therefore
        // we only apply the work-around for Symbian.
#if defined(__SYMBIAN32__)
# define GTEST_CREF_WORKAROUND_ const&
#else
# define GTEST_CREF_WORKAROUND_
#endif

        // When this operand is a const char* or char*, if the other operand
        // is a ::std::string or ::string, we print this operand as a C string
        // rather than a pointer (we do the same for wide strings); otherwise
        // we print it as a pointer to be safe.

        // This internal macro is used to avoid duplicated code.
#define GTEST_FORMAT_IMPL_(operand2_type, operand1_printer)\
    inline String FormatForComparisonFailureMessage(\
            operand2_type::value_type* GTEST_CREF_WORKAROUND_ str, \
            const operand2_type& /*operand2*/) {\
        return operand1_printer(str);\
    }\
    inline String FormatForComparisonFailureMessage(\
            const operand2_type::value_type* GTEST_CREF_WORKAROUND_ str, \
            const operand2_type& /*operand2*/) {\
        return operand1_printer(str);\
    }

        GTEST_FORMAT_IMPL_(::std::string, String::ShowCStringQuoted)
#if GTEST_HAS_STD_WSTRING
        GTEST_FORMAT_IMPL_(::std::wstring, String::ShowWideCStringQuoted)
#endif  // GTEST_HAS_STD_WSTRING

#if GTEST_HAS_GLOBAL_STRING
        GTEST_FORMAT_IMPL_(::string, String::ShowCStringQuoted)
#endif  // GTEST_HAS_GLOBAL_STRING
#if GTEST_HAS_GLOBAL_WSTRING
        GTEST_FORMAT_IMPL_(::wstring, String::ShowWideCStringQuoted)
#endif  // GTEST_HAS_GLOBAL_WSTRING

#undef GTEST_FORMAT_IMPL_

        // The next four overloads handle the case where the operand being
        // printed is a char/wchar_t pointer and the other operand is not a
        // string/wstring object.  In such cases, we just print the operand as
        // a pointer to be safe.
#define GTEST_FORMAT_CHAR_PTR_IMPL_(CharType)                       \
    template <typename T>                                             \
    String FormatForComparisonFailureMessage(CharType* GTEST_CREF_WORKAROUND_ p, \
            const T&) { \
        return PrintToString(static_cast<const void*>(p));              \
    }

        GTEST_FORMAT_CHAR_PTR_IMPL_(char)
        GTEST_FORMAT_CHAR_PTR_IMPL_(const char)
        GTEST_FORMAT_CHAR_PTR_IMPL_(wchar_t)
        GTEST_FORMAT_CHAR_PTR_IMPL_(const wchar_t)

#undef GTEST_FORMAT_CHAR_PTR_IMPL_

        // Constructs and returns the message for an equality assertion
        // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
        //
        // The first four parameters are the expressions used in the assertion
        // and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
        // where foo is 5 and bar is 6, we have:
        //
        //   expected_expression: "foo"
        //   actual_expression:   "bar"
        //   expected_value:      "5"
        //   actual_value:        "6"
        //
        // The ignoring_case parameter is true iff the assertion is a
        // *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
        // be inserted into the message.
        GTEST_API_ AssertionResult EqFailure(const char *expected_expression,
                                             const char *actual_expression,
                                             const String &expected_value,
                                             const String &actual_value,
                                             bool ignoring_case);

        AssertionResult EqSuccess(const char *expected_expression,
                                  const char *actual_expression,
                                  const String &expected_value,
                                  const String &actual_value,
                                  bool ignoring_case);

        // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
        GTEST_API_ String GetBoolAssertionFailureMessage(
            const AssertionResult &assertion_result,
            const char *expression_text,
            const char *actual_predicate_value,
            const char *expected_predicate_value);

        GTEST_API_ String GetBoolAssertionSuccessMessage(
            const AssertionResult &assertion_result,
            const char *expression_text,
            const char *actual_predicate_value,
            const char *expected_predicate_value);

        // This template class represents an IEEE floating-point number
        // (either single-precision or double-precision, depending on the
        // template parameters).
        //
        // The purpose of this class is to do more sophisticated number
        // comparison.  (Due to round-off error, etc, it's very unlikely that
        // two floating-points will be equal exactly.  Hence a naive
        // comparison by the == operation often doesn't work.)
        //
        // Format of IEEE floating-point:
        //
        //   The most-significant bit being the leftmost, an IEEE
        //   floating-point looks like
        //
        //     sign_bit exponent_bits fraction_bits
        //
        //   Here, sign_bit is a single bit that designates the sign of the
        //   number.
        //
        //   For float, there are 8 exponent bits and 23 fraction bits.
        //
        //   For double, there are 11 exponent bits and 52 fraction bits.
        //
        //   More details can be found at
        //   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
        //
        // Template parameter:
        //
        //   RawType: the raw floating-point type (either float or double)
        template <typename RawType>
        class FloatingPoint
        {
        public:
            // Defines the unsigned integer type that has the same size as the
            // floating point number.
            typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;

            // Constants.

            // # of bits in a number.
            static const size_t kBitCount = 8 * sizeof(RawType);

            // # of fraction bits in a number.
            static const size_t kFractionBitCount =
                std::numeric_limits<RawType>::digits - 1;

            // # of exponent bits in a number.
            static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;

            // The mask for the sign bit.
            static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);

            // The mask for the fraction bits.
            static const Bits kFractionBitMask =
                ~static_cast<Bits>(0) >> (kExponentBitCount + 1);

            // The mask for the exponent bits.
            static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);

            // How many ULP's (Units in the Last Place) we want to tolerate when
            // comparing two numbers.  The larger the value, the more error we
            // allow.  A 0 value means that two numbers must be exactly the same
            // to be considered equal.
            //
            // The maximum error of a single floating-point operation is 0.5
            // units in the last place.  On Intel CPU's, all floating-point
            // calculations are done with 80-bit precision, while double has 64
            // bits.  Therefore, 4 should be enough for ordinary use.
            //
            // See the following article for more details on ULP:
            // http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm.
            static const size_t kMaxUlps = 4;

            // Constructs a FloatingPoint from a raw floating-point number.
            //
            // On an Intel CPU, passing a non-normalized NAN (Not a Number)
            // around may change its bits, although the new value is guaranteed
            // to be also a NAN.  Therefore, don't expect this constructor to
            // preserve the bits in x when x is a NAN.
            explicit FloatingPoint(const RawType &x)
            {
                u_.value_ = x;
            }

            // Static methods

            // Reinterprets a bit pattern as a floating-point number.
            //
            // This function is needed to test the AlmostEquals() method.
            static RawType ReinterpretBits(const Bits bits)
            {
                FloatingPoint fp(0);
                fp.u_.bits_ = bits;
                return fp.u_.value_;
            }

            // Returns the floating-point number that represent positive infinity.
            static RawType Infinity()
            {
                return ReinterpretBits(kExponentBitMask);
            }

            // Non-static methods

            // Returns the bits that represents this number.
            const Bits &bits() const
            {
                return u_.bits_;
            }

            // Returns the exponent bits of this number.
            Bits exponent_bits() const
            {
                return kExponentBitMask & u_.bits_;
            }

            // Returns the fraction bits of this number.
            Bits fraction_bits() const
            {
                return kFractionBitMask & u_.bits_;
            }

            // Returns the sign bit of this number.
            Bits sign_bit() const
            {
                return kSignBitMask & u_.bits_;
            }

            // Returns true iff this is NAN (not a number).
            bool is_nan() const
            {
                // It's a NAN if the exponent bits are all ones and the fraction
                // bits are not entirely zeros.
                return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
            }

            // Returns true iff this number is at most kMaxUlps ULP's away from
            // rhs.  In particular, this function:
            //
            //   - returns false if either number is (or both are) NAN.
            //   - treats really large numbers as almost equal to infinity.
            //   - thinks +0.0 and -0.0 are 0 DLP's apart.
            bool AlmostEquals(const FloatingPoint &rhs) const
            {
                // The IEEE standard says that any comparison operation involving
                // a NAN must return false.
                if (is_nan() || rhs.is_nan())
                {
                    return false;
                }

                return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
                       <= kMaxUlps;
            }

        private:
            // The data type used to store the actual floating-point number.
            union FloatingPointUnion
            {
                RawType value_;  // The raw floating-point number.
                Bits bits_;      // The bits that represent the number.
            };

            // Converts an integer from the sign-and-magnitude representation to
            // the biased representation.  More precisely, let N be 2 to the
            // power of (kBitCount - 1), an integer x is represented by the
            // unsigned number x + N.
            //
            // For instance,
            //
            //   -N + 1 (the most negative number representable using
            //          sign-and-magnitude) is represented by 1;
            //   0      is represented by N; and
            //   N - 1  (the biggest number representable using
            //          sign-and-magnitude) is represented by 2N - 1.
            //
            // Read http://en.wikipedia.org/wiki/Signed_number_representations
            // for more details on signed number representations.
            static Bits SignAndMagnitudeToBiased(const Bits &sam)
            {
                if (kSignBitMask & sam)
                {
                    // sam represents a negative number.
                    return ~sam + 1;
                }
                else
                {
                    // sam represents a positive number.
                    return kSignBitMask | sam;
                }
            }

            // Given two numbers in the sign-and-magnitude representation,
            // returns the distance between them as an unsigned number.
            static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
                    const Bits &sam2)
            {
                const Bits biased1 = SignAndMagnitudeToBiased(sam1);
                const Bits biased2 = SignAndMagnitudeToBiased(sam2);
                return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
            }

            FloatingPointUnion u_;
        };

        // Typedefs the instances of the FloatingPoint template class that we
        // care to use.
        typedef FloatingPoint<float> Float;
        typedef FloatingPoint<double> Double;

        // In order to catch the mistake of putting tests that use different
        // test fixture classes in the same test case, we need to assign
        // unique IDs to fixture classes and compare them.  The TypeId type is
        // used to hold such IDs.  The user should treat TypeId as an opaque
        // type: the only operation allowed on TypeId values is to compare
        // them for equality using the == operator.
        typedef const void *TypeId;

        template <typename T>
        class TypeIdHelper
        {
        public:
            // dummy_ must not have a const type.  Otherwise an overly eager
            // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
            // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
            static bool dummy_;
        };

        template <typename T>
        bool TypeIdHelper<T>::dummy_ = false;

        // GetTypeId<T>() returns the ID of type T.  Different values will be
        // returned for different types.  Calling the function twice with the
        // same type argument is guaranteed to return the same ID.
        template <typename T>
        TypeId GetTypeId()
        {
            // The compiler is required to allocate a different
            // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
            // the template.  Therefore, the address of dummy_ is guaranteed to
            // be unique.
            return &(TypeIdHelper<T>::dummy_);
        }

        // Returns the type ID of ::testing::Test.  Always call this instead
        // of GetTypeId< ::testing::Test>() to get the type ID of
        // ::testing::Test, as the latter may give the wrong result due to a
        // suspected linker bug when compiling Google Test as a Mac OS X
        // framework.
        GTEST_API_ TypeId GetTestTypeId();

        // Defines the abstract factory interface that creates instances
        // of a Test object.
        class TestFactoryBase
        {
        public:
            virtual ~TestFactoryBase() {}

            // Creates a test instance to run. The instance is both created and destroyed
            // within TestInfoImpl::Run()
            virtual Test *CreateTest() = 0;
            virtual Test *CreateTest(void *, void *) = 0;

        protected:
            TestFactoryBase() {}

        private:
            GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
        };

        // This class provides implementation of TeastFactoryBase interface.
        // It is used in TEST and TEST_F macros.
        template <class TestClass>
        class TestFactoryImpl : public TestFactoryBase
        {
        public:
            virtual Test *CreateTest()
            {
                return new TestClass();
            }

            virtual Test *CreateTest(void *, void *)
            {
                return NULL;
            }
        };

        template <class TestClass>
        class TestFactoryImplSo : public TestFactoryBase
        {
        public:
            virtual Test *CreateTest()
            {
                return NULL;
            }
            virtual Test *CreateTest(void *instance, void *data)
            {
                return new TestClass(instance, data);
            }
        };

#if GTEST_OS_WINDOWS

        // Predicate-formatters for implementing the HRESULT checking macros
        // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
        // We pass a long instead of HRESULT to avoid causing an
        // include dependency for the HRESULT type.
        GTEST_API_ AssertionResult IsHRESULTSuccess(const char *expr,
                long hr);  // NOLINT
        GTEST_API_ AssertionResult IsHRESULTFailure(const char *expr,
                long hr);  // NOLINT

#endif  // GTEST_OS_WINDOWS

        // Types of SetUpTestCase() and TearDownTestCase() functions.
        typedef void (*SetUpTestCaseFunc)();
        typedef void (*TearDownTestCaseFunc)();

        // Creates a new TestInfo object and registers it with Google Test;
        // returns the created object.
        //
        // Arguments:
        //
        //   test_case_name:   name of the test case
        //   name:             name of the test
        //   type_param        the name of the test's type parameter, or NULL if
        //                     this is not  a typed or a type-parameterized test.
        //   value_param       text representation of the test's value parameter,
        //                     or NULL if this is not a type-parameterized test.
        //   fixture_class_id: ID of the test fixture class
        //   set_up_tc:        pointer to the function that sets up the test case
        //   tear_down_tc:     pointer to the function that tears down the test case
        //   factory:          pointer to the factory that creates a test object.
        //                     The newly created TestInfo instance will assume
        //                     ownership of the factory object.
        GTEST_API_ TestInfo *MakeAndRegisterTestInfo(
            const char *test_case_name, const char *name,
            const char *type_param,
            const char *value_param,
            TypeId fixture_class_id,
            SetUpTestCaseFunc set_up_tc,
            TearDownTestCaseFunc tear_down_tc,
            TestFactoryBase *factory);

        // If *pstr starts with the given prefix, modifies *pstr to be right
        // past the prefix and returns true; otherwise leaves *pstr unchanged
        // and returns false.  None of pstr, *pstr, and prefix can be NULL.
        GTEST_API_ bool SkipPrefix(const char *prefix, const char **pstr);

#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P

        // State of the definition of a type-parameterized test case.
        class GTEST_API_ TypedTestCasePState
        {
        public:
            TypedTestCasePState() : registered_(false) {}

            // Adds the given test name to defined_test_names_ and return true
            // if the test case hasn't been registered; otherwise aborts the
            // program.
            bool AddTestName(const char *file, int line, const char *case_name,
                             const char *test_name)
            {
                if (registered_)
                {
                    fprintf(stderr, "%s Test %s must be defined before "
                            "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n",
                            FormatFileLocation(file, line).c_str(), test_name, case_name);
                    fflush(stderr);
                    posix::Abort();
                }

                defined_test_names_.insert(test_name);
                return true;
            }

            // Verifies that registered_tests match the test names in
            // defined_test_names_; returns registered_tests if successful, or
            // aborts the program otherwise.
            const char *VerifyRegisteredTestNames(
                const char *file, int line, const char *registered_tests);

        private:
            bool registered_;
            ::std::set<const char *> defined_test_names_;
        };

        // Skips to the first non-space char after the first comma in 'str';
        // returns NULL if no comma is found in 'str'.
        inline const char *SkipComma(const char *str)
        {
            const char *comma = strchr(str, ',');

            if (comma == NULL)
            {
                return NULL;
            }

            while (IsSpace(*(++comma))) {}

            return comma;
        }

        // Returns the prefix of 'str' before the first comma in it; returns
        // the entire string if it contains no comma.
        inline String GetPrefixUntilComma(const char *str)
        {
            const char *comma = strchr(str, ',');
            return comma == NULL ? String(str) : String(str, comma - str);
        }

        // TypeParameterizedTest<Fixture, TestSel, Types>::Register()
        // registers a list of type-parameterized tests with Google Test.  The
        // return value is insignificant - we just need to return something
        // such that we can call this function in a namespace scope.
        //
        // Implementation note: The GTEST_TEMPLATE_ macro declares a template
        // template parameter.  It's defined in gtest-type-util.h.
        template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
        class TypeParameterizedTest
        {
        public:
            // 'index' is the index of the test in the type list 'Types'
            // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
            // Types).  Valid values for 'index' are [0, N - 1] where N is the
            // length of Types.
            static bool Register(const char *prefix, const char *case_name,
                                 const char *test_names, int index)
            {
                typedef typename Types::Head Type;
                typedef Fixture<Type> FixtureClass;
                typedef typename GTEST_BIND_(TestSel, Type) TestClass;
                // First, registers the first type-parameterized test in the type
                // list.
                MakeAndRegisterTestInfo(
                    String::Format("%s%s%s/%d", prefix, prefix[0] == '\0' ? "" : "/",
                                   case_name, index).c_str(),
                    GetPrefixUntilComma(test_names).c_str(),
                    GetTypeName<Type>().c_str(),
                    NULL,  // No value parameter.
                    GetTypeId<FixtureClass>(),
                    TestClass::SetUpTestCase,
                    TestClass::TearDownTestCase,
                    new TestFactoryImpl<TestClass>);
                // Next, recurses (at compile time) with the tail of the type list.
                return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>
                       ::Register(prefix, case_name, test_names, index + 1);
            }
        };

        // The base case for the compile time recursion.
        template <GTEST_TEMPLATE_ Fixture, class TestSel>
        class TypeParameterizedTest<Fixture, TestSel, Types0>
        {
        public:
            static bool Register(const char * /*prefix*/, const char * /*case_name*/,
                                 const char * /*test_names*/, int /*index*/)
            {
                return true;
            }
        };

        // TypeParameterizedTestCase<Fixture, Tests, Types>::Register()
        // registers *all combinations* of 'Tests' and 'Types' with Google
        // Test.  The return value is insignificant - we just need to return
        // something such that we can call this function in a namespace scope.
        template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
        class TypeParameterizedTestCase
        {
        public:
            static bool Register(const char *prefix, const char *case_name,
                                 const char *test_names)
            {
                typedef typename Tests::Head Head;
                // First, register the first test in 'Test' for each type in 'Types'.
                TypeParameterizedTest<Fixture, Head, Types>::Register(
                    prefix, case_name, test_names, 0);
                // Next, recurses (at compile time) with the tail of the test list.
                return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
                       ::Register(prefix, case_name, SkipComma(test_names));
            }
        };

        // The base case for the compile time recursion.
        template <GTEST_TEMPLATE_ Fixture, typename Types>
        class TypeParameterizedTestCase<Fixture, Templates0, Types>
        {
        public:
            static bool Register(const char * /*prefix*/, const char * /*case_name*/,
                                 const char * /*test_names*/)
            {
                return true;
            }
        };

#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P

        // Returns the current OS stack trace as a String.
        //
        // The maximum number of stack frames to be included is specified by
        // the gtest_stack_trace_depth flag.  The skip_count parameter
        // specifies the number of top frames to be skipped, which doesn't
        // count against the number of frames to be included.
        //
        // For example, if Foo() calls Bar(), which in turn calls
        // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
        // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
        GTEST_API_ String GetCurrentOsStackTraceExceptTop(UnitTest *unit_test,
                int skip_count);

        // Helpers for suppressing warnings on unreachable code or constant
        // condition.

        // Always returns true.
        GTEST_API_ bool AlwaysTrue();

        // Always returns false.
        inline bool AlwaysFalse()
        {
            return !AlwaysTrue();
        }

        // Helper for suppressing false warning from Clang on a const char*
        // variable declared in a conditional expression always being NULL in
        // the else branch.
        struct GTEST_API_ ConstCharPtr
        {
            ConstCharPtr(const char *str) : value(str) {}
            operator bool() const
            {
                return true;
            }
            const char *value;
        };

        // A simple Linear Congruential Generator for generating random
        // numbers with a uniform distribution.  Unlike rand() and srand(), it
        // doesn't use global state (and therefore can't interfere with user
        // code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
        // but it's good enough for our purposes.
        class GTEST_API_ Random
        {
        public:
            static const UInt32 kMaxRange = 1u << 31;

            explicit Random(UInt32 seed) : state_(seed) {}

            void Reseed(UInt32 seed)
            {
                state_ = seed;
            }

            // Generates a random number from [0, range).  Crashes if 'range' is
            // 0 or greater than kMaxRange.
            UInt32 Generate(UInt32 range);

        private:
            UInt32 state_;
            GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
        };

        // Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
        // compiler error iff T1 and T2 are different types.
        template <typename T1, typename T2>
        struct CompileAssertTypesEqual;

        template <typename T>
        struct CompileAssertTypesEqual<T, T>
        {
        };

        // Removes the reference from a type if it is a reference type,
        // otherwise leaves it unchanged.  This is the same as
        // tr1::remove_reference, which is not widely available yet.
        template <typename T>
        struct RemoveReference
        {
            typedef T type;
        };  // NOLINT
        template <typename T>
        struct RemoveReference<T &>
        {
            typedef T type;
        };  // NOLINT

        // A handy wrapper around RemoveReference that works when the argument
        // T depends on template parameters.
#define GTEST_REMOVE_REFERENCE_(T) \
    typename ::testing::internal::RemoveReference<T>::type

        // Removes const from a type if it is a const type, otherwise leaves
        // it unchanged.  This is the same as tr1::remove_const, which is not
        // widely available yet.
        template <typename T>
        struct RemoveConst
        {
            typedef T type;
        };  // NOLINT
        template <typename T>
        struct RemoveConst<const T>
        {
            typedef T type;
        };  // NOLINT

        // MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
        // definition to fail to remove the const in 'const int[3]' and 'const
        // char[3][4]'.  The following specialization works around the bug.
        // However, it causes trouble with GCC and thus needs to be
        // conditionally compiled.
#if defined(_MSC_VER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
        template <typename T, size_t N>
        struct RemoveConst<const T[N]>
        {
            typedef typename RemoveConst<T>::type type[N];
        };
#endif

        // A handy wrapper around RemoveConst that works when the argument
        // T depends on template parameters.
#define GTEST_REMOVE_CONST_(T) \
    typename ::testing::internal::RemoveConst<T>::type

        // Turns const U&, U&, const U, and U all into U.
#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
    GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))

        // Adds reference to a type if it is not a reference type,
        // otherwise leaves it unchanged.  This is the same as
        // tr1::add_reference, which is not widely available yet.
        template <typename T>
        struct AddReference
        {
            typedef T &type;
        };  // NOLINT
        template <typename T>
        struct AddReference<T &>
        {
            typedef T &type;
        };  // NOLINT

        // A handy wrapper around AddReference that works when the argument T
        // depends on template parameters.
#define GTEST_ADD_REFERENCE_(T) \
    typename ::testing::internal::AddReference<T>::type

        // Adds a reference to const on top of T as necessary.  For example,
        // it transforms
        //
        //   char         ==> const char&
        //   const char   ==> const char&
        //   char&        ==> const char&
        //   const char&  ==> const char&
        //
        // The argument T must depend on some template parameters.
#define GTEST_REFERENCE_TO_CONST_(T) \
    GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))

        // ImplicitlyConvertible<From, To>::value is a compile-time bool
        // constant that's true iff type From can be implicitly converted to
        // type To.
        template <typename From, typename To>
        class ImplicitlyConvertible
        {
        private:
            // We need the following helper functions only for their types.
            // They have no implementations.

            // MakeFrom() is an expression whose type is From.  We cannot simply
            // use From(), as the type From may not have a public default
            // constructor.
            static From MakeFrom();

            // These two functions are overloaded.  Given an expression
            // Helper(x), the compiler will pick the first version if x can be
            // implicitly converted to type To; otherwise it will pick the
            // second version.
            //
            // The first version returns a value of size 1, and the second
            // version returns a value of size 2.  Therefore, by checking the
            // size of Helper(x), which can be done at compile time, we can tell
            // which version of Helper() is used, and hence whether x can be
            // implicitly converted to type To.
            static char Helper(To);
            static char(&Helper(...))[2];   // NOLINT

            // We have to put the 'public' section after the 'private' section,
            // or MSVC refuses to compile the code.
        public:
            // MSVC warns about implicitly converting from double to int for
            // possible loss of data, so we need to temporarily disable the
            // warning.
#ifdef _MSC_VER
# pragma warning(push)          // Saves the current warning state.
# pragma warning(disable:4244)  // Temporarily disables warning 4244.

            static const bool value =
                sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
# pragma warning(pop)           // Restores the warning state.
#elif defined(__BORLANDC__)
            // C++Builder cannot use member overload resolution during template
            // instantiation.  The simplest workaround is to use its C++0x type traits
            // functions (C++Builder 2009 and above only).
            static const bool value = __is_convertible(From, To);
#else
            static const bool value =
                sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
#endif  // _MSV_VER
        };
        template <typename From, typename To>
        const bool ImplicitlyConvertible<From, To>::value;

        // IsAProtocolMessage<T>::value is a compile-time bool constant that's
        // true iff T is type ProtocolMessage, proto2::Message, or a subclass
        // of those.
        template <typename T>
        struct IsAProtocolMessage
                : public bool_constant <
                ImplicitlyConvertible<const T *, const ::ProtocolMessage *>::value ||
                ImplicitlyConvertible<const T *, const ::proto2::Message *>::value >
        {
        };

        // When the compiler sees expression IsContainerTest<C>(0), if C is an
        // STL-style container class, the first overload of IsContainerTest
        // will be viable (since both C::iterator* and C::const_iterator* are
        // valid types and NULL can be implicitly converted to them).  It will
        // be picked over the second overload as 'int' is a perfect match for
        // the type of argument 0.  If C::iterator or C::const_iterator is not
        // a valid type, the first overload is not viable, and the second
        // overload will be picked.  Therefore, we can determine whether C is
        // a container class by checking the type of IsContainerTest<C>(0).
        // The value of the expression is insignificant.
        //
        // Note that we look for both C::iterator and C::const_iterator.  The
        // reason is that C++ injects the name of a class as a member of the
        // class itself (e.g. you can refer to class iterator as either
        // 'iterator' or 'iterator::iterator').  If we look for C::iterator
        // only, for example, we would mistakenly think that a class named
        // iterator is an STL container.
        //
        // Also note that the simpler approach of overloading
        // IsContainerTest(typename C::const_iterator*) and
        // IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
        typedef int IsContainer;
        template <class C>
        IsContainer IsContainerTest(int /* dummy */,
                                    typename C::iterator * /* it */ = NULL,
                                    typename C::const_iterator * /* const_it */ = NULL)
        {
            return 0;
        }

        typedef char IsNotContainer;
        template <class C>
        IsNotContainer IsContainerTest(long /* dummy */)
        {
            return '\0';
        }

        // EnableIf<condition>::type is void when 'Cond' is true, and
        // undefined when 'Cond' is false.  To use SFINAE to make a function
        // overload only apply when a particular expression is true, add
        // "typename EnableIf<expression>::type* = 0" as the last parameter.
        template<bool> struct EnableIf;
        template<> struct EnableIf<true>
        {
            typedef void type;
        };  // NOLINT

        // Utilities for native arrays.

        // ArrayEq() compares two k-dimensional native arrays using the
        // elements' operator==, where k can be any integer >= 0.  When k is
        // 0, ArrayEq() degenerates into comparing a single pair of values.

        template <typename T, typename U>
        bool ArrayEq(const T *lhs, size_t size, const U *rhs);

        // This generic version is used when k is 0.
        template <typename T, typename U>
        inline bool ArrayEq(const T &lhs, const U &rhs)
        {
            return lhs == rhs;
        }

        // This overload is used when k >= 1.
        template <typename T, typename U, size_t N>
        inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N])
        {
            return internal::ArrayEq(lhs, N, rhs);
        }

        // This helper reduces code bloat.  If we instead put its logic inside
        // the previous ArrayEq() function, arrays with different sizes would
        // lead to different copies of the template code.
        template <typename T, typename U>
        bool ArrayEq(const T *lhs, size_t size, const U *rhs)
        {
            for (size_t i = 0; i != size; i++)
            {
                if (!internal::ArrayEq(lhs[i], rhs[i]))
                {
                    return false;
                }
            }

            return true;
        }

        // Finds the first element in the iterator range [begin, end) that
        // equals elem.  Element may be a native array type itself.
        template <typename Iter, typename Element>
        Iter ArrayAwareFind(Iter begin, Iter end, const Element &elem)
        {
            for (Iter it = begin; it != end; ++it)
            {
                if (internal::ArrayEq(*it, elem))
                {
                    return it;
                }
            }

            return end;
        }

        // CopyArray() copies a k-dimensional native array using the elements'
        // operator=, where k can be any integer >= 0.  When k is 0,
        // CopyArray() degenerates into copying a single value.

        template <typename T, typename U>
        void CopyArray(const T *from, size_t size, U *to);

        // This generic version is used when k is 0.
        template <typename T, typename U>
        inline void CopyArray(const T &from, U *to)
        {
            *to = from;
        }

        // This overload is used when k >= 1.
        template <typename T, typename U, size_t N>
        inline void CopyArray(const T(&from)[N], U(*to)[N])
        {
            internal::CopyArray(from, N, *to);
        }

        // This helper reduces code bloat.  If we instead put its logic inside
        // the previous CopyArray() function, arrays with different sizes
        // would lead to different copies of the template code.
        template <typename T, typename U>
        void CopyArray(const T *from, size_t size, U *to)
        {
            for (size_t i = 0; i != size; i++)
            {
                internal::CopyArray(from[i], to + i);
            }
        }

        // The relation between an NativeArray object (see below) and the
        // native array it represents.
        enum RelationToSource
        {
            kReference,  // The NativeArray references the native array.
            kCopy        // The NativeArray makes a copy of the native array and
            // owns the copy.
        };

        // Adapts a native array to a read-only STL-style container.  Instead
        // of the complete STL container concept, this adaptor only implements
        // members useful for Google Mock's container matchers.  New members
        // should be added as needed.  To simplify the implementation, we only
        // support Element being a raw type (i.e. having no top-level const or
        // reference modifier).  It's the client's responsibility to satisfy
        // this requirement.  Element can be an array type itself (hence
        // multi-dimensional arrays are supported).
        template <typename Element>
        class NativeArray
        {
        public:
            // STL-style container typedefs.
            typedef Element value_type;
            typedef Element *iterator;
            typedef const Element *const_iterator;

            // Constructs from a native array.
            NativeArray(const Element *array, size_t count, RelationToSource relation)
            {
                Init(array, count, relation);
            }

            // Copy constructor.
            NativeArray(const NativeArray &rhs)
            {
                Init(rhs.array_, rhs.size_, rhs.relation_to_source_);
            }

            ~NativeArray()
            {
                // Ensures that the user doesn't instantiate NativeArray with a
                // const or reference type.
                static_cast<void>(StaticAssertTypeEqHelper < Element,
                                  GTEST_REMOVE_REFERENCE_AND_CONST_(Element) > ());

                if (relation_to_source_ == kCopy)
                {
                    delete[] array_;
                }
            }

            // STL-style container methods.
            size_t size() const
            {
                return size_;
            }
            const_iterator begin() const
            {
                return array_;
            }
            const_iterator end() const
            {
                return array_ + size_;
            }
            bool operator==(const NativeArray &rhs) const
            {
                return size() == rhs.size() &&
                       ArrayEq(begin(), size(), rhs.begin());
            }

        private:
            // Initializes this object; makes a copy of the input array if
            // 'relation' is kCopy.
            void Init(const Element *array, size_t a_size, RelationToSource relation)
            {
                if (relation == kReference)
                {
                    array_ = array;
                }
                else
                {
                    Element *const copy = new Element[a_size];
                    CopyArray(array, a_size, copy);
                    array_ = copy;
                }

                size_ = a_size;
                relation_to_source_ = relation;
            }

            const Element *array_;
            size_t size_;
            RelationToSource relation_to_source_;

            GTEST_DISALLOW_ASSIGN_(NativeArray);
        };

    }  // namespace internal
}  // namespace testing

#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
    ::testing::internal::AssertHelper(result_type, file, line, message) \
    = ::testing::Message()

#define GTEST_MESSAGE_(message, result_type) \
    GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)

#define GTEST_FATAL_FAILURE_(message) \
    return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)

#define GTEST_NONFATAL_FAILURE_(message) \
    GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)

#define GTEST_SUCCESS_(message) \
    GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)

// Suppresses MSVC warnings 4072 (unreachable code) for the code following
// statement if it returns or throws (or doesn't return or throw in some
// situations).
#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
    if (::testing::internal::AlwaysTrue()) { statement; }

#define GTEST_TEST_THROW_(statement, expected_exception, fail) \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::ConstCharPtr gtest_msg = "") { \
        bool gtest_caught_expected = false; \
        try { \
            GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
        } \
        catch (expected_exception const&) { \
            gtest_caught_expected = true; \
        } \
        catch (...) { \
            gtest_msg.value = \
                              "Expected: " #statement " throws an exception of type " \
                              #expected_exception ".\n  Actual: it throws a different type."; \
            goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
        } \
        if (!gtest_caught_expected) { \
            gtest_msg.value = \
                              "Expected: " #statement " throws an exception of type " \
                              #expected_exception ".\n  Actual: it throws nothing."; \
            goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
        } \
    } else \
        GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
            fail(gtest_msg.value)

#define GTEST_TEST_NO_THROW_(statement, fail) \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::AlwaysTrue()) { \
        try { \
            GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
        } \
        catch (...) { \
            goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
        } \
    } else \
        GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
            fail("Expected: " #statement " doesn't throw an exception.\n" \
                 "  Actual: it throws.")

#define GTEST_TEST_ANY_THROW_(statement, fail) \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::AlwaysTrue()) { \
        bool gtest_caught_any = false; \
        try { \
            GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
        } \
        catch (...) { \
            gtest_caught_any = true; \
        } \
        if (!gtest_caught_any) { \
            goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
        } \
    } else \
        GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
            fail("Expected: " #statement " throws an exception.\n" \
                 "  Actual: it doesn't.")


// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
// either a boolean expression or an AssertionResult. text is a textual
// represenation of expression as it was passed into the EXPECT_TRUE.
#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (const ::testing::AssertionResult gtest_ar_ = \
            ::testing::AssertionResult(expression)) \
        printf("%s",(::testing::internal::GetBoolAssertionSuccessMessage(\
                     gtest_ar_, text, #expected, #expected).c_str()) ); \
    else \
        fail(::testing::internal::GetBoolAssertionFailureMessage(\
                gtest_ar_, text, #actual, #expected).c_str())

#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::AlwaysTrue()) { \
        ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
        GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
        if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
            goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
        } \
    } else \
        GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
            fail("Expected: " #statement " doesn't generate new fatal " \
                 "failures in the current thread.\n" \
                 "  Actual: it does.")

// Expands to the name of the class that implements the given test.
#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
    test_case_name##_##test_name##_Test

// Helper macro for defining tests.
#ifdef SO_BTEST

#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
    class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
    public:\
        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)(void *instance ,void *data):parent_class(instance, data) {}\
    private:\
        virtual void TestBody();\
        static ::testing::TestInfo* const test_info_;\
        GTEST_DISALLOW_COPY_AND_ASSIGN_(\
                                        GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
    };\
    \
    ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
    ::test_info_ =\
                  ::testing::internal::MakeAndRegisterTestInfo(\
                          #test_case_name, #test_name, "", "", \
                          (parent_id), \
                          parent_class::SetUpTestCase, \
                          parent_class::TearDownTestCase, \
                          new ::testing::internal::TestFactoryImplSo<\
                          GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
    void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()

#else // no define SO_BTEST
#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
    class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
    public:\
        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)():parent_class() {}\
    private:\
        virtual void TestBody();\
        static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
        GTEST_DISALLOW_COPY_AND_ASSIGN_(\
                                        GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
    };\
    \
    ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
    ::test_info_ =\
                  ::testing::internal::MakeAndRegisterTestInfo(\
                          #test_case_name, #test_name, NULL, NULL, \
                          (parent_id), \
                          parent_class::SetUpTestCase, \
                          parent_class::TearDownTestCase, \
                          new ::testing::internal::TestFactoryImpl<\
                          GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
    void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
#endif  // SO_BTEST

#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
